home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / bits / string2.h < prev    next >
C/C++ Source or Header  |  2006-05-08  |  48KB  |  1,356 lines
  1. /* Machine-independant string function optimizations.
  2.    Copyright (C) 1997-2003, 2004 Free Software Foundation, Inc.
  3.    This file is part of the GNU C Library.
  4.    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
  5.  
  6.    The GNU C Library is free software; you can redistribute it and/or
  7.    modify it under the terms of the GNU Lesser General Public
  8.    License as published by the Free Software Foundation; either
  9.    version 2.1 of the License, or (at your option) any later version.
  10.  
  11.    The GNU C Library is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.    Lesser General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU Lesser General Public
  17.    License along with the GNU C Library; if not, write to the Free
  18.    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19.    02111-1307 USA.  */
  20.  
  21. #ifndef _STRING_H
  22. # error "Never use <bits/string2.h> directly; include <string.h> instead."
  23. #endif
  24.  
  25. #if !defined __NO_STRING_INLINES && !defined __BOUNDED_POINTERS__
  26.  
  27. /* Unlike the definitions in the header <bits/string.h> the
  28.    definitions contained here are not optimized down to assembler
  29.    level.  Those optimizations are not always a good idea since this
  30.    means the code size increases a lot.  Instead the definitions here
  31.    optimize some functions in a way which do not dramatically
  32.    increase the code size and which do not use assembler.  The main
  33.    trick is to use GCC's `__builtin_constant_p' function.
  34.  
  35.    Every function XXX which has a defined version in
  36.    <bits/string.h> must be accompanied by a symbol _HAVE_STRING_ARCH_XXX
  37.    to make sure we don't get redefinitions.
  38.  
  39.    We must use here macros instead of inline functions since the
  40.    trick won't work with the latter.  */
  41.  
  42. #ifndef __STRING_INLINE
  43. # ifdef __cplusplus
  44. #  define __STRING_INLINE inline
  45. # else
  46. #  define __STRING_INLINE extern __inline
  47. # endif
  48. #endif
  49.  
  50. #if _STRING_ARCH_unaligned
  51. /* If we can do unaligned memory accesses we must know the endianess.  */
  52. # include <endian.h>
  53. # include <bits/types.h>
  54.  
  55. # if __BYTE_ORDER == __LITTLE_ENDIAN
  56. #  define __STRING2_SMALL_GET16(src, idx) \
  57.      (((__const unsigned char *) (__const char *) (src))[idx + 1] << 8          \
  58.       | ((__const unsigned char *) (__const char *) (src))[idx])
  59. #  define __STRING2_SMALL_GET32(src, idx) \
  60.      (((((__const unsigned char *) (__const char *) (src))[idx + 3] << 8      \
  61.     | ((__const unsigned char *) (__const char *) (src))[idx + 2]) << 8   \
  62.        | ((__const unsigned char *) (__const char *) (src))[idx + 1]) << 8    \
  63.       | ((__const unsigned char *) (__const char *) (src))[idx])
  64. # else
  65. #  define __STRING2_SMALL_GET16(src, idx) \
  66.      (((__const unsigned char *) (__const char *) (src))[idx] << 8          \
  67.       | ((__const unsigned char *) (__const char *) (src))[idx + 1])
  68. #  define __STRING2_SMALL_GET32(src, idx) \
  69.      (((((__const unsigned char *) (__const char *) (src))[idx] << 8          \
  70.     | ((__const unsigned char *) (__const char *) (src))[idx + 1]) << 8   \
  71.        | ((__const unsigned char *) (__const char *) (src))[idx + 2]) << 8    \
  72.       | ((__const unsigned char *) (__const char *) (src))[idx + 3])
  73. # endif
  74. #else
  75. /* These are a few types we need for the optimizations if we cannot
  76.    use unaligned memory accesses.  */
  77. # define __STRING2_COPY_TYPE(N) \
  78.   typedef struct { unsigned char __arr[N]; }                      \
  79.     __attribute__ ((__packed__)) __STRING2_COPY_ARR##N
  80. __STRING2_COPY_TYPE (2);
  81. __STRING2_COPY_TYPE (3);
  82. __STRING2_COPY_TYPE (4);
  83. __STRING2_COPY_TYPE (5);
  84. __STRING2_COPY_TYPE (6);
  85. __STRING2_COPY_TYPE (7);
  86. __STRING2_COPY_TYPE (8);
  87. # undef __STRING2_COPY_TYPE
  88. #endif
  89.  
  90. /* Dereferencing a pointer arg to run sizeof on it fails for the void
  91.    pointer case, so we use this instead.
  92.    Note that __x is evaluated twice. */
  93. #define __string2_1bptr_p(__x) \
  94.   ((size_t)(const void *)((__x) + 1) - (size_t)(const void *)(__x) == 1)
  95.  
  96. /* Set N bytes of S to C.  */
  97. #if !defined _HAVE_STRING_ARCH_memset
  98. # if !__GNUC_PREREQ (3, 0)
  99. #  if _STRING_ARCH_unaligned
  100. #   define memset(s, c, n) \
  101.   (__extension__ (__builtin_constant_p (n) && (n) <= 16                  \
  102.           ? ((n) == 1                              \
  103.              ? __memset_1 (s, c)                      \
  104.              : __memset_gc (s, c, n))                      \
  105.           : (__builtin_constant_p (c) && (c) == '\0'              \
  106.              ? ({ void *__s = (s); __bzero (__s, n); __s; })          \
  107.              : memset (s, c, n))))
  108.  
  109. #   define __memset_1(s, c) ({ void *__s = (s);                      \
  110.                 *((__uint8_t *) __s) = (__uint8_t) c; __s; })
  111.  
  112. #   define __memset_gc(s, c, n) \
  113.   ({ void *__s = (s);                                  \
  114.      union {                                      \
  115.        unsigned int __ui;                              \
  116.        unsigned short int __usi;                          \
  117.        unsigned char __uc;                              \
  118.      } *__u = __s;                                  \
  119.      __uint8_t __c = (__uint8_t) (c);                          \
  120.                                           \
  121.      /* This `switch' statement will be removed at compile-time.  */          \
  122.      switch ((unsigned int) (n))                          \
  123.        {                                      \
  124.        case 15:                                      \
  125.      __u->__ui = __c * 0x01010101;                          \
  126.      __u = __extension__ ((void *) __u + 4);                  \
  127.        case 11:                                      \
  128.      __u->__ui = __c * 0x01010101;                          \
  129.      __u = __extension__ ((void *) __u + 4);                  \
  130.        case 7:                                      \
  131.      __u->__ui = __c * 0x01010101;                          \
  132.      __u = __extension__ ((void *) __u + 4);                  \
  133.        case 3:                                      \
  134.      __u->__usi = (unsigned short int) __c * 0x0101;              \
  135.      __u = __extension__ ((void *) __u + 2);                  \
  136.      __u->__uc = (unsigned char) __c;                      \
  137.      break;                                      \
  138.                                           \
  139.        case 14:                                      \
  140.      __u->__ui = __c * 0x01010101;                          \
  141.      __u = __extension__ ((void *) __u + 4);                  \
  142.        case 10:                                      \
  143.      __u->__ui = __c * 0x01010101;                          \
  144.      __u = __extension__ ((void *) __u + 4);                  \
  145.        case 6:                                      \
  146.      __u->__ui = __c * 0x01010101;                          \
  147.      __u = __extension__ ((void *) __u + 4);                  \
  148.        case 2:                                      \
  149.      __u->__usi = (unsigned short int) __c * 0x0101;              \
  150.      break;                                      \
  151.                                           \
  152.        case 13:                                      \
  153.      __u->__ui = __c * 0x01010101;                          \
  154.      __u = __extension__ ((void *) __u + 4);                  \
  155.        case 9:                                      \
  156.      __u->__ui = __c * 0x01010101;                          \
  157.      __u = __extension__ ((void *) __u + 4);                  \
  158.        case 5:                                      \
  159.      __u->__ui = __c * 0x01010101;                          \
  160.      __u = __extension__ ((void *) __u + 4);                  \
  161.        case 1:                                      \
  162.      __u->__uc = (unsigned char) __c;                      \
  163.      break;                                      \
  164.                                           \
  165.        case 16:                                      \
  166.      __u->__ui = __c * 0x01010101;                          \
  167.      __u = __extension__ ((void *) __u + 4);                  \
  168.        case 12:                                      \
  169.      __u->__ui = __c * 0x01010101;                          \
  170.      __u = __extension__ ((void *) __u + 4);                  \
  171.        case 8:                                      \
  172.      __u->__ui = __c * 0x01010101;                          \
  173.      __u = __extension__ ((void *) __u + 4);                  \
  174.        case 4:                                      \
  175.      __u->__ui = __c * 0x01010101;                          \
  176.        case 0:                                      \
  177.      break;                                      \
  178.        }                                      \
  179.                                           \
  180.      __s; })
  181. #  else
  182. #   define memset(s, c, n) \
  183.   (__extension__ (__builtin_constant_p (c) && (c) == '\0'              \
  184.           ? ({ void *__s = (s); __bzero (__s, n); __s; })          \
  185.           : memset (s, c, n)))
  186. #  endif
  187. # endif
  188.  
  189. /* GCC < 3.0 optimizes memset(s, 0, n) but not bzero(s, n).
  190.    The optimization is broken before EGCS 1.1.
  191.    GCC 3.0+ has __builtin_bzero as well, but at least till GCC 3.4
  192.    if it decides to call the library function, it calls memset
  193.    and not bzero.  */
  194. # if __GNUC_PREREQ (2, 91)
  195. #  define __bzero(s, n) __builtin_memset (s, '\0', n)
  196. # endif
  197.  
  198. #endif
  199.  
  200.  
  201. /* Copy N bytes from SRC to DEST, returning pointer to byte following the
  202.    last copied.  */
  203. #ifdef __USE_GNU
  204. # if !defined _HAVE_STRING_ARCH_mempcpy || defined _FORCE_INLINES
  205. #  ifndef _HAVE_STRING_ARCH_mempcpy
  206. #   if __GNUC_PREREQ (3, 4)
  207. #    define __mempcpy(dest, src, n) __builtin_mempcpy (dest, src, n)
  208. #   elif __GNUC_PREREQ (3, 0)
  209. #    define __mempcpy(dest, src, n) \
  210.   (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n)      \
  211.           && __string2_1bptr_p (src) && n <= 8                  \
  212.           ? __builtin_memcpy (dest, src, n) + (n)              \
  213.           : __mempcpy (dest, src, n)))
  214. #   else
  215. #    define __mempcpy(dest, src, n) \
  216.   (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n)      \
  217.           && __string2_1bptr_p (src) && n <= 8                  \
  218.           ? __mempcpy_small (dest, __mempcpy_args (src), n)          \
  219.           : __mempcpy (dest, src, n)))
  220. #   endif
  221. /* In glibc we use this function frequently but for namespace reasons
  222.    we have to use the name `__mempcpy'.  */
  223. #   define mempcpy(dest, src, n) __mempcpy (dest, src, n)
  224. #  endif
  225.  
  226. #  if !__GNUC_PREREQ (3, 0) || defined _FORCE_INLINES
  227. #   if _STRING_ARCH_unaligned
  228. #    ifndef _FORCE_INLINES
  229. #     define __mempcpy_args(src) \
  230.      ((__const char *) (src))[0], ((__const char *) (src))[2],              \
  231.      ((__const char *) (src))[4], ((__const char *) (src))[6],              \
  232.      __extension__ __STRING2_SMALL_GET16 (src, 0),                  \
  233.      __extension__ __STRING2_SMALL_GET16 (src, 4),                  \
  234.      __extension__ __STRING2_SMALL_GET32 (src, 0),                  \
  235.      __extension__ __STRING2_SMALL_GET32 (src, 4)
  236. #    endif
  237. __STRING_INLINE void *__mempcpy_small (void *, char, char, char, char,
  238.                        __uint16_t, __uint16_t, __uint32_t,
  239.                        __uint32_t, size_t);
  240. __STRING_INLINE void *
  241. __mempcpy_small (void *__dest1,
  242.          char __src0_1, char __src2_1, char __src4_1, char __src6_1,
  243.          __uint16_t __src0_2, __uint16_t __src4_2,
  244.          __uint32_t __src0_4, __uint32_t __src4_4,
  245.          size_t __srclen)
  246. {
  247.   union {
  248.     __uint32_t __ui;
  249.     __uint16_t __usi;
  250.     unsigned char __uc;
  251.     unsigned char __c;
  252.   } *__u = __dest1;
  253.   switch ((unsigned int) __srclen)
  254.     {
  255.     case 1:
  256.       __u->__c = __src0_1;
  257.       __u = __extension__ ((void *) __u + 1);
  258.       break;
  259.     case 2:
  260.       __u->__usi = __src0_2;
  261.       __u = __extension__ ((void *) __u + 2);
  262.       break;
  263.     case 3:
  264.       __u->__usi = __src0_2;
  265.       __u = __extension__ ((void *) __u + 2);
  266.       __u->__c = __src2_1;
  267.       __u = __extension__ ((void *) __u + 1);
  268.       break;
  269.     case 4:
  270.       __u->__ui = __src0_4;
  271.       __u = __extension__ ((void *) __u + 4);
  272.       break;
  273.     case 5:
  274.       __u->__ui = __src0_4;
  275.       __u = __extension__ ((void *) __u + 4);
  276.       __u->__c = __src4_1;
  277.       __u = __extension__ ((void *) __u + 1);
  278.       break;
  279.     case 6:
  280.       __u->__ui = __src0_4;
  281.       __u = __extension__ ((void *) __u + 4);
  282.       __u->__usi = __src4_2;
  283.       __u = __extension__ ((void *) __u + 2);
  284.       break;
  285.     case 7:
  286.       __u->__ui = __src0_4;
  287.       __u = __extension__ ((void *) __u + 4);
  288.       __u->__usi = __src4_2;
  289.       __u = __extension__ ((void *) __u + 2);
  290.       __u->__c = __src6_1;
  291.       __u = __extension__ ((void *) __u + 1);
  292.       break;
  293.     case 8:
  294.       __u->__ui = __src0_4;
  295.       __u = __extension__ ((void *) __u + 4);
  296.       __u->__ui = __src4_4;
  297.       __u = __extension__ ((void *) __u + 4);
  298.       break;
  299.     }
  300.   return (void *) __u;
  301. }
  302. #   else
  303. #    ifndef _FORCE_INLINES
  304. #     define __mempcpy_args(src) \
  305.      ((__const char *) (src))[0],                          \
  306.      __extension__ ((__STRING2_COPY_ARR2)                      \
  307.       { { ((__const char *) (src))[0], ((__const char *) (src))[1] } }),      \
  308.      __extension__ ((__STRING2_COPY_ARR3)                      \
  309.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  310.       ((__const char *) (src))[2] } }),                      \
  311.      __extension__ ((__STRING2_COPY_ARR4)                      \
  312.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  313.       ((__const char *) (src))[2], ((__const char *) (src))[3] } }),      \
  314.      __extension__ ((__STRING2_COPY_ARR5)                      \
  315.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  316.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  317.       ((__const char *) (src))[4] } }),                      \
  318.      __extension__ ((__STRING2_COPY_ARR6)                      \
  319.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  320.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  321.       ((__const char *) (src))[4], ((__const char *) (src))[5] } }),      \
  322.      __extension__ ((__STRING2_COPY_ARR7)                      \
  323.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  324.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  325.       ((__const char *) (src))[4], ((__const char *) (src))[5],          \
  326.       ((__const char *) (src))[6] } }),                      \
  327.      __extension__ ((__STRING2_COPY_ARR8)                      \
  328.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  329.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  330.       ((__const char *) (src))[4], ((__const char *) (src))[5],          \
  331.       ((__const char *) (src))[6], ((__const char *) (src))[7] } })
  332. #    endif
  333. __STRING_INLINE void *__mempcpy_small (void *, char, __STRING2_COPY_ARR2,
  334.                        __STRING2_COPY_ARR3,
  335.                        __STRING2_COPY_ARR4,
  336.                        __STRING2_COPY_ARR5,
  337.                        __STRING2_COPY_ARR6,
  338.                        __STRING2_COPY_ARR7,
  339.                        __STRING2_COPY_ARR8, size_t);
  340. __STRING_INLINE void *
  341. __mempcpy_small (void *__dest, char __src1,
  342.          __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3,
  343.          __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5,
  344.          __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7,
  345.          __STRING2_COPY_ARR8 __src8, size_t __srclen)
  346. {
  347.   union {
  348.     char __c;
  349.     __STRING2_COPY_ARR2 __sca2;
  350.     __STRING2_COPY_ARR3 __sca3;
  351.     __STRING2_COPY_ARR4 __sca4;
  352.     __STRING2_COPY_ARR5 __sca5;
  353.     __STRING2_COPY_ARR6 __sca6;
  354.     __STRING2_COPY_ARR7 __sca7;
  355.     __STRING2_COPY_ARR8 __sca8;
  356.   } *__u = __dest;
  357.   switch ((unsigned int) __srclen)
  358.     {
  359.     case 1:
  360.       __u->__c = __src1;
  361.       break;
  362.     case 2:
  363.       __extension__ __u->__sca2 = __src2;
  364.       break;
  365.     case 3:
  366.       __extension__ __u->__sca3 = __src3;
  367.       break;
  368.     case 4:
  369.       __extension__ __u->__sca4 = __src4;
  370.       break;
  371.     case 5:
  372.       __extension__ __u->__sca5 = __src5;
  373.       break;
  374.     case 6:
  375.       __extension__ __u->__sca6 = __src6;
  376.       break;
  377.     case 7:
  378.       __extension__ __u->__sca7 = __src7;
  379.       break;
  380.     case 8:
  381.       __extension__ __u->__sca8 = __src8;
  382.       break;
  383.     }
  384.   return __extension__ ((void *) __u + __srclen);
  385. }
  386. #   endif
  387. #  endif
  388. # endif
  389. #endif
  390.  
  391.  
  392. /* Return pointer to C in S.  */
  393. #ifndef _HAVE_STRING_ARCH_strchr
  394. extern void *__rawmemchr (const void *__s, int __c);
  395. # if __GNUC_PREREQ (3, 2)
  396. #  define strchr(s, c) \
  397.   (__extension__ (__builtin_constant_p (c) && !__builtin_constant_p (s)          \
  398.           && (c) == '\0'                          \
  399.           ? (char *) __rawmemchr (s, c)                      \
  400.           : __builtin_strchr (s, c)))
  401. # else
  402. #  define strchr(s, c) \
  403.   (__extension__ (__builtin_constant_p (c) && (c) == '\0'              \
  404.           ? (char *) __rawmemchr (s, c)                      \
  405.           : strchr (s, c)))
  406. # endif
  407. #endif
  408.  
  409.  
  410. /* Copy SRC to DEST.  */
  411. #if (!defined _HAVE_STRING_ARCH_strcpy && !__GNUC_PREREQ (3, 0)) \
  412.     || defined _FORCE_INLINES
  413. # if !defined _HAVE_STRING_ARCH_strcpy && !__GNUC_PREREQ (3, 0)
  414. #  define strcpy(dest, src) \
  415.   (__extension__ (__builtin_constant_p (src)                      \
  416.           ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8          \
  417.              ? __strcpy_small (dest, __strcpy_args (src),          \
  418.                        strlen (src) + 1)              \
  419.              : (char *) memcpy (dest, src, strlen (src) + 1))          \
  420.           : strcpy (dest, src)))
  421. # endif
  422.  
  423. # if _STRING_ARCH_unaligned
  424. #  ifndef _FORCE_INLINES
  425. #   define __strcpy_args(src) \
  426.      __extension__ __STRING2_SMALL_GET16 (src, 0),                  \
  427.      __extension__ __STRING2_SMALL_GET16 (src, 4),                  \
  428.      __extension__ __STRING2_SMALL_GET32 (src, 0),                  \
  429.      __extension__ __STRING2_SMALL_GET32 (src, 4)
  430. #  endif
  431. __STRING_INLINE char *__strcpy_small (char *, __uint16_t, __uint16_t,
  432.                       __uint32_t, __uint32_t, size_t);
  433. __STRING_INLINE char *
  434. __strcpy_small (char *__dest,
  435.         __uint16_t __src0_2, __uint16_t __src4_2,
  436.         __uint32_t __src0_4, __uint32_t __src4_4,
  437.         size_t __srclen)
  438. {
  439.   union {
  440.     __uint32_t __ui;
  441.     __uint16_t __usi;
  442.     unsigned char __uc;
  443.   } *__u = (void *) __dest;
  444.   switch ((unsigned int) __srclen)
  445.     {
  446.     case 1:
  447.       __u->__uc = '\0';
  448.       break;
  449.     case 2:
  450.       __u->__usi = __src0_2;
  451.       break;
  452.     case 3:
  453.       __u->__usi = __src0_2;
  454.       __u = __extension__ ((void *) __u + 2);
  455.       __u->__uc = '\0';
  456.       break;
  457.     case 4:
  458.       __u->__ui = __src0_4;
  459.       break;
  460.     case 5:
  461.       __u->__ui = __src0_4;
  462.       __u = __extension__ ((void *) __u + 4);
  463.       __u->__uc = '\0';
  464.       break;
  465.     case 6:
  466.       __u->__ui = __src0_4;
  467.       __u = __extension__ ((void *) __u + 4);
  468.       __u->__usi = __src4_2;
  469.       break;
  470.     case 7:
  471.       __u->__ui = __src0_4;
  472.       __u = __extension__ ((void *) __u + 4);
  473.       __u->__usi = __src4_2;
  474.       __u = __extension__ ((void *) __u + 2);
  475.       __u->__uc = '\0';
  476.       break;
  477.     case 8:
  478.       __u->__ui = __src0_4;
  479.       __u = __extension__ ((void *) __u + 4);
  480.       __u->__ui = __src4_4;
  481.       break;
  482.     }
  483.   return __dest;
  484. }
  485. # else
  486. #  ifndef _FORCE_INLINES
  487. #   define __strcpy_args(src) \
  488.      __extension__ ((__STRING2_COPY_ARR2)                      \
  489.       { { ((__const char *) (src))[0], '\0' } }),                  \
  490.      __extension__ ((__STRING2_COPY_ARR3)                      \
  491.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  492.       '\0' } }),                                  \
  493.      __extension__ ((__STRING2_COPY_ARR4)                      \
  494.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  495.       ((__const char *) (src))[2], '\0' } }),                  \
  496.      __extension__ ((__STRING2_COPY_ARR5)                      \
  497.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  498.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  499.       '\0' } }),                                  \
  500.      __extension__ ((__STRING2_COPY_ARR6)                      \
  501.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  502.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  503.       ((__const char *) (src))[4], '\0' } }),                  \
  504.      __extension__ ((__STRING2_COPY_ARR7)                      \
  505.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  506.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  507.       ((__const char *) (src))[4], ((__const char *) (src))[5],          \
  508.       '\0' } }),                                  \
  509.      __extension__ ((__STRING2_COPY_ARR8)                      \
  510.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  511.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  512.       ((__const char *) (src))[4], ((__const char *) (src))[5],          \
  513.       ((__const char *) (src))[6], '\0' } })
  514. #  endif
  515. __STRING_INLINE char *__strcpy_small (char *, __STRING2_COPY_ARR2,
  516.                       __STRING2_COPY_ARR3,
  517.                       __STRING2_COPY_ARR4,
  518.                       __STRING2_COPY_ARR5,
  519.                       __STRING2_COPY_ARR6,
  520.                       __STRING2_COPY_ARR7,
  521.                       __STRING2_COPY_ARR8, size_t);
  522. __STRING_INLINE char *
  523. __strcpy_small (char *__dest,
  524.         __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3,
  525.         __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5,
  526.         __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7,
  527.         __STRING2_COPY_ARR8 __src8, size_t __srclen)
  528. {
  529.   union {
  530.     char __c;
  531.     __STRING2_COPY_ARR2 __sca2;
  532.     __STRING2_COPY_ARR3 __sca3;
  533.     __STRING2_COPY_ARR4 __sca4;
  534.     __STRING2_COPY_ARR5 __sca5;
  535.     __STRING2_COPY_ARR6 __sca6;
  536.     __STRING2_COPY_ARR7 __sca7;
  537.     __STRING2_COPY_ARR8 __sca8;
  538.   } *__u = (void *) __dest;
  539.   switch ((unsigned int) __srclen)
  540.     {
  541.     case 1:
  542.       __u->__c = '\0';
  543.       break;
  544.     case 2:
  545.       __extension__ __u->__sca2 = __src2;
  546.       break;
  547.     case 3:
  548.       __extension__ __u->__sca3 = __src3;
  549.       break;
  550.     case 4:
  551.       __extension__ __u->__sca4 = __src4;
  552.       break;
  553.     case 5:
  554.       __extension__ __u->__sca5 = __src5;
  555.       break;
  556.     case 6:
  557.       __extension__ __u->__sca6 = __src6;
  558.       break;
  559.     case 7:
  560.       __extension__ __u->__sca7 = __src7;
  561.       break;
  562.     case 8:
  563.       __extension__ __u->__sca8 = __src8;
  564.       break;
  565.   }
  566.   return __dest;
  567. }
  568. # endif
  569. #endif
  570.  
  571.  
  572. /* Copy SRC to DEST, returning pointer to final NUL byte.  */
  573. #ifdef __USE_GNU
  574. # if !defined _HAVE_STRING_ARCH_stpcpy || defined _FORCE_INLINES
  575. #  ifndef _HAVE_STRING_ARCH_stpcpy
  576. #   if __GNUC_PREREQ (3, 4)
  577. #    define __stpcpy(dest, src) __builtin_stpcpy (dest, src)
  578. #   elif __GNUC_PREREQ (3, 0)
  579. #    define __stpcpy(dest, src) \
  580.   (__extension__ (__builtin_constant_p (src)                      \
  581.           ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8          \
  582.              ? __builtin_strcpy (dest, src) + strlen (src)          \
  583.              : ((char *) (__mempcpy) (dest, src, strlen (src) + 1)    \
  584.             - 1))                              \
  585.           : __stpcpy (dest, src)))
  586. #   else
  587. #    define __stpcpy(dest, src) \
  588.   (__extension__ (__builtin_constant_p (src)                      \
  589.           ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8          \
  590.              ? __stpcpy_small (dest, __stpcpy_args (src),          \
  591.                        strlen (src) + 1)              \
  592.              : ((char *) (__mempcpy) (dest, src, strlen (src) + 1)    \
  593.             - 1))                              \
  594.           : __stpcpy (dest, src)))
  595. #   endif
  596. /* In glibc we use this function frequently but for namespace reasons
  597.    we have to use the name `__stpcpy'.  */
  598. #   define stpcpy(dest, src) __stpcpy (dest, src)
  599. #  endif
  600.  
  601. #  if !__GNUC_PREREQ (3, 0) || defined _FORCE_INLINES
  602. #   if _STRING_ARCH_unaligned
  603. #    ifndef _FORCE_INLINES
  604. #     define __stpcpy_args(src) \
  605.      __extension__ __STRING2_SMALL_GET16 (src, 0),                  \
  606.      __extension__ __STRING2_SMALL_GET16 (src, 4),                  \
  607.      __extension__ __STRING2_SMALL_GET32 (src, 0),                  \
  608.      __extension__ __STRING2_SMALL_GET32 (src, 4)
  609. #    endif
  610. __STRING_INLINE char *__stpcpy_small (char *, __uint16_t, __uint16_t,
  611.                       __uint32_t, __uint32_t, size_t);
  612. __STRING_INLINE char *
  613. __stpcpy_small (char *__dest,
  614.         __uint16_t __src0_2, __uint16_t __src4_2,
  615.         __uint32_t __src0_4, __uint32_t __src4_4,
  616.         size_t __srclen)
  617. {
  618.   union {
  619.     unsigned int __ui;
  620.     unsigned short int __usi;
  621.     unsigned char __uc;
  622.     char __c;
  623.   } *__u = (void *) __dest;
  624.   switch ((unsigned int) __srclen)
  625.     {
  626.     case 1:
  627.       __u->__uc = '\0';
  628.       break;
  629.     case 2:
  630.       __u->__usi = __src0_2;
  631.       __u = __extension__ ((void *) __u + 1);
  632.       break;
  633.     case 3:
  634.       __u->__usi = __src0_2;
  635.       __u = __extension__ ((void *) __u + 2);
  636.       __u->__uc = '\0';
  637.       break;
  638.     case 4:
  639.       __u->__ui = __src0_4;
  640.       __u = __extension__ ((void *) __u + 3);
  641.       break;
  642.     case 5:
  643.       __u->__ui = __src0_4;
  644.       __u = __extension__ ((void *) __u + 4);
  645.       __u->__uc = '\0';
  646.       break;
  647.     case 6:
  648.       __u->__ui = __src0_4;
  649.       __u = __extension__ ((void *) __u + 4);
  650.       __u->__usi = __src4_2;
  651.       __u = __extension__ ((void *) __u + 1);
  652.       break;
  653.     case 7:
  654.       __u->__ui = __src0_4;
  655.       __u = __extension__ ((void *) __u + 4);
  656.       __u->__usi = __src4_2;
  657.       __u = __extension__ ((void *) __u + 2);
  658.       __u->__uc = '\0';
  659.       break;
  660.     case 8:
  661.       __u->__ui = __src0_4;
  662.       __u = __extension__ ((void *) __u + 4);
  663.       __u->__ui = __src4_4;
  664.       __u = __extension__ ((void *) __u + 3);
  665.       break;
  666.     }
  667.   return &__u->__c;
  668. }
  669. #   else
  670. #    ifndef _FORCE_INLINES
  671. #     define __stpcpy_args(src) \
  672.      __extension__ ((__STRING2_COPY_ARR2)                      \
  673.       { { ((__const char *) (src))[0], '\0' } }),                  \
  674.      __extension__ ((__STRING2_COPY_ARR3)                      \
  675.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  676.       '\0' } }),                                  \
  677.      __extension__ ((__STRING2_COPY_ARR4)                      \
  678.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  679.       ((__const char *) (src))[2], '\0' } }),                  \
  680.      __extension__ ((__STRING2_COPY_ARR5)                      \
  681.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  682.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  683.       '\0' } }),                                  \
  684.      __extension__ ((__STRING2_COPY_ARR6)                      \
  685.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  686.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  687.       ((__const char *) (src))[4], '\0' } }),                  \
  688.      __extension__ ((__STRING2_COPY_ARR7)                      \
  689.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  690.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  691.       ((__const char *) (src))[4], ((__const char *) (src))[5],          \
  692.       '\0' } }),                                  \
  693.      __extension__ ((__STRING2_COPY_ARR8)                      \
  694.       { { ((__const char *) (src))[0], ((__const char *) (src))[1],          \
  695.       ((__const char *) (src))[2], ((__const char *) (src))[3],          \
  696.       ((__const char *) (src))[4], ((__const char *) (src))[5],          \
  697.       ((__const char *) (src))[6], '\0' } })
  698. #    endif
  699. __STRING_INLINE char *__stpcpy_small (char *, __STRING2_COPY_ARR2,
  700.                       __STRING2_COPY_ARR3,
  701.                       __STRING2_COPY_ARR4,
  702.                       __STRING2_COPY_ARR5,
  703.                       __STRING2_COPY_ARR6,
  704.                       __STRING2_COPY_ARR7,
  705.                       __STRING2_COPY_ARR8, size_t);
  706. __STRING_INLINE char *
  707. __stpcpy_small (char *__dest,
  708.         __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3,
  709.         __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5,
  710.         __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7,
  711.         __STRING2_COPY_ARR8 __src8, size_t __srclen)
  712. {
  713.   union {
  714.     char __c;
  715.     __STRING2_COPY_ARR2 __sca2;
  716.     __STRING2_COPY_ARR3 __sca3;
  717.     __STRING2_COPY_ARR4 __sca4;
  718.     __STRING2_COPY_ARR5 __sca5;
  719.     __STRING2_COPY_ARR6 __sca6;
  720.     __STRING2_COPY_ARR7 __sca7;
  721.     __STRING2_COPY_ARR8 __sca8;
  722.   } *__u = (void *) __dest;
  723.   switch ((unsigned int) __srclen)
  724.     {
  725.     case 1:
  726.       __u->__c = '\0';
  727.       break;
  728.     case 2:
  729.       __extension__ __u->__sca2 = __src2;
  730.       break;
  731.     case 3:
  732.       __extension__ __u->__sca3 = __src3;
  733.       break;
  734.     case 4:
  735.       __extension__ __u->__sca4 = __src4;
  736.       break;
  737.     case 5:
  738.       __extension__ __u->__sca5 = __src5;
  739.       break;
  740.     case 6:
  741.       __extension__ __u->__sca6 = __src6;
  742.       break;
  743.     case 7:
  744.       __extension__ __u->__sca7 = __src7;
  745.       break;
  746.     case 8:
  747.       __extension__ __u->__sca8 = __src8;
  748.       break;
  749.   }
  750.   return __dest + __srclen - 1;
  751. }
  752. #   endif
  753. #  endif
  754. # endif
  755. #endif
  756.  
  757.  
  758. /* Copy no more than N characters of SRC to DEST.  */
  759. #ifndef _HAVE_STRING_ARCH_strncpy
  760. # if __GNUC_PREREQ (3, 2)
  761. #  define strncpy(dest, src, n) __builtin_strncpy (dest, src, n)
  762. # else
  763. #  define strncpy(dest, src, n) \
  764.   (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n)      \
  765.           ? (strlen (src) + 1 >= ((size_t) (n))                  \
  766.              ? (char *) memcpy (dest, src, n)                  \
  767.              : strncpy (dest, src, n))                      \
  768.           : strncpy (dest, src, n)))
  769. # endif
  770. #endif
  771.  
  772.  
  773. /* Append no more than N characters from SRC onto DEST.  */
  774. #ifndef _HAVE_STRING_ARCH_strncat
  775. # ifdef _USE_STRING_ARCH_strchr
  776. #  define strncat(dest, src, n) \
  777.   (__extension__ ({ char *__dest = (dest);                      \
  778.             __builtin_constant_p (src) && __builtin_constant_p (n)    \
  779.             ? (strlen (src) < ((size_t) (n))                  \
  780.                ? strcat (__dest, src)                      \
  781.                : (*((char *) __mempcpy (strchr (__dest, '\0'),          \
  782.                         src, n)) = '\0', __dest))     \
  783.             : strncat (dest, src, n); }))
  784. # elif __GNUC_PREREQ (3, 2)
  785. #  define strncat(dest, src, n) __builtin_strncat (dest, src, n)
  786. # else
  787. #  define strncat(dest, src, n) \
  788.   (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n)      \
  789.           ? (strlen (src) < ((size_t) (n))                  \
  790.              ? strcat (dest, src)                      \
  791.              : strncat (dest, src, n))                      \
  792.           : strncat (dest, src, n)))
  793. # endif
  794. #endif
  795.  
  796.  
  797. /* Compare characters of S1 and S2.  */
  798. #ifndef _HAVE_STRING_ARCH_strcmp
  799. # if __GNUC_PREREQ (3, 2)
  800. #  define strcmp(s1, s2) \
  801.   __extension__                                      \
  802.   ({ size_t __s1_len, __s2_len;                              \
  803.      (__builtin_constant_p (s1) && __builtin_constant_p (s2)              \
  804.       && (__s1_len = strlen (s1), __s2_len = strlen (s2),              \
  805.       (!__string2_1bptr_p (s1) || __s1_len >= 4)                  \
  806.       && (!__string2_1bptr_p (s2) || __s2_len >= 4))              \
  807.       ? __builtin_strcmp (s1, s2)                          \
  808.       : (__builtin_constant_p (s1) && __string2_1bptr_p (s1)              \
  809.      && (__s1_len = strlen (s1), __s1_len < 4)                  \
  810.      ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2)              \
  811.         ? __builtin_strcmp (s1, s2)                          \
  812.         : __strcmp_cg (s1, s2, __s1_len))                      \
  813.      : (__builtin_constant_p (s2) && __string2_1bptr_p (s2)              \
  814.         && (__s2_len = strlen (s2), __s2_len < 4)                  \
  815.         ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1)          \
  816.            ? __builtin_strcmp (s1, s2)                      \
  817.            : __strcmp_gc (s1, s2, __s2_len))                  \
  818.         : __builtin_strcmp (s1, s2)))); })
  819. # else
  820. #  define strcmp(s1, s2) \
  821.   __extension__                                      \
  822.   ({ size_t __s1_len, __s2_len;                              \
  823.      (__builtin_constant_p (s1) && __builtin_constant_p (s2)              \
  824.       && (__s1_len = strlen (s1), __s2_len = strlen (s2),              \
  825.       (!__string2_1bptr_p (s1) || __s1_len >= 4)                  \
  826.       && (!__string2_1bptr_p (s2) || __s2_len >= 4))              \
  827.       ? memcmp ((__const char *) (s1), (__const char *) (s2),              \
  828.         (__s1_len < __s2_len ? __s1_len : __s2_len) + 1)          \
  829.       : (__builtin_constant_p (s1) && __string2_1bptr_p (s1)              \
  830.      && (__s1_len = strlen (s1), __s1_len < 4)                  \
  831.      ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2)              \
  832.         ? __strcmp_cc (s1, s2, __s1_len)                      \
  833.         : __strcmp_cg (s1, s2, __s1_len))                      \
  834.      : (__builtin_constant_p (s2) && __string2_1bptr_p (s2)              \
  835.         && (__s2_len = strlen (s2), __s2_len < 4)                  \
  836.         ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1)          \
  837.            ? __strcmp_cc (s1, s2, __s2_len)                      \
  838.            : __strcmp_gc (s1, s2, __s2_len))                  \
  839.         : strcmp (s1, s2)))); })
  840. # endif
  841.  
  842. # define __strcmp_cc(s1, s2, l) \
  843.   (__extension__ ({ register int __result =                      \
  844.               (((__const unsigned char *) (__const char *) (s1))[0]   \
  845.                - ((__const unsigned char *) (__const char *)(s2))[0]);\
  846.             if (l > 0 && __result == 0)                      \
  847.               {                                  \
  848.             __result = (((__const unsigned char *)              \
  849.                      (__const char *) (s1))[1]              \
  850.                     - ((__const unsigned char *)          \
  851.                        (__const char *) (s2))[1]);          \
  852.             if (l > 1 && __result == 0)                  \
  853.               {                              \
  854.                 __result =                          \
  855.                   (((__const unsigned char *)              \
  856.                 (__const char *) (s1))[2]              \
  857.                    - ((__const unsigned char *)              \
  858.                   (__const char *) (s2))[2]);              \
  859.                 if (l > 2 && __result == 0)                  \
  860.                   __result =                      \
  861.                 (((__const unsigned char *)              \
  862.                   (__const char *) (s1))[3]              \
  863.                  - ((__const unsigned char *)              \
  864.                     (__const char *) (s2))[3]);              \
  865.               }                              \
  866.               }                                  \
  867.             __result; }))
  868.  
  869. # define __strcmp_cg(s1, s2, l1) \
  870.   (__extension__ ({ __const unsigned char *__s2 =                  \
  871.               (__const unsigned char *) (__const char *) (s2);          \
  872.             register int __result =                      \
  873.               (((__const unsigned char *) (__const char *) (s1))[0]   \
  874.                - __s2[0]);                          \
  875.             if (l1 > 0 && __result == 0)                  \
  876.               {                                  \
  877.             __result = (((__const unsigned char *)              \
  878.                      (__const char *) (s1))[1] - __s2[1]);    \
  879.             if (l1 > 1 && __result == 0)                  \
  880.               {                              \
  881.                 __result = (((__const unsigned char *)          \
  882.                      (__const char *) (s1))[2] - __s2[2]);\
  883.                 if (l1 > 2 && __result == 0)              \
  884.                   __result = (((__const unsigned char *)          \
  885.                       (__const char *)  (s1))[3]          \
  886.                       - __s2[3]);                  \
  887.               }                              \
  888.               }                                  \
  889.             __result; }))
  890.  
  891. # define __strcmp_gc(s1, s2, l2) \
  892.   (__extension__ ({ __const unsigned char *__s1 =                  \
  893.               (__const unsigned char *) (__const char *) (s1);          \
  894.             register int __result =                      \
  895.               __s1[0] - ((__const unsigned char *)              \
  896.                  (__const char *) (s2))[0];              \
  897.             if (l2 > 0 && __result == 0)                  \
  898.               {                                  \
  899.             __result = (__s1[1]                      \
  900.                     - ((__const unsigned char *)          \
  901.                        (__const char *) (s2))[1]);          \
  902.             if (l2 > 1 && __result == 0)                  \
  903.               {                              \
  904.                 __result =                          \
  905.                   (__s1[2] - ((__const unsigned char *)          \
  906.                       (__const char *) (s2))[2]);          \
  907.                 if (l2 > 2 && __result == 0)              \
  908.                   __result =                      \
  909.                 (__s1[3]                      \
  910.                  - ((__const unsigned char *)              \
  911.                     (__const char *) (s2))[3]);              \
  912.               }                              \
  913.               }                                  \
  914.             __result; }))
  915. #endif
  916.  
  917.  
  918. /* Compare N characters of S1 and S2.  */
  919. #ifndef _HAVE_STRING_ARCH_strncmp
  920. # define strncmp(s1, s2, n)                              \
  921.   (__extension__ (__builtin_constant_p (n)                      \
  922.           && ((__builtin_constant_p (s1)                  \
  923.                && strlen (s1) < ((size_t) (n)))                  \
  924.               || (__builtin_constant_p (s2)                  \
  925.               && strlen (s2) < ((size_t) (n))))              \
  926.           ? strcmp (s1, s2) : strncmp (s1, s2, n)))
  927. #endif
  928.  
  929.  
  930. /* Return the length of the initial segment of S which
  931.    consists entirely of characters not in REJECT.  */
  932. #if !defined _HAVE_STRING_ARCH_strcspn || defined _FORCE_INLINES
  933. # ifndef _HAVE_STRING_ARCH_strcspn
  934. #  if __GNUC_PREREQ (3, 2)
  935. #   define strcspn(s, reject) \
  936.   __extension__                                      \
  937.   ({ char __r0, __r1, __r2;                              \
  938.      (__builtin_constant_p (reject) && __string2_1bptr_p (reject)          \
  939.       ? ((__builtin_constant_p (s) && __string2_1bptr_p (s))              \
  940.      ? __builtin_strcspn (s, reject)                      \
  941.      : ((__r0 = ((__const char *) (reject))[0], __r0 == '\0')          \
  942.         ? strlen (s)                              \
  943.         : ((__r1 = ((__const char *) (reject))[1], __r1 == '\0')          \
  944.            ? __strcspn_c1 (s, __r0)                          \
  945.            : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0')          \
  946.           ? __strcspn_c2 (s, __r0, __r1)                  \
  947.           : (((__const char *) (reject))[3] == '\0'              \
  948.              ? __strcspn_c3 (s, __r0, __r1, __r2)              \
  949.              : __builtin_strcspn (s, reject))))))              \
  950.       : __builtin_strcspn (s, reject)); })
  951. #  else
  952. #   define strcspn(s, reject) \
  953.   __extension__                                      \
  954.   ({ char __r0, __r1, __r2;                              \
  955.      (__builtin_constant_p (reject) && __string2_1bptr_p (reject)          \
  956.       ? ((__r0 = ((__const char *) (reject))[0], __r0 == '\0')              \
  957.      ? strlen (s)                                  \
  958.      : ((__r1 = ((__const char *) (reject))[1], __r1 == '\0')          \
  959.         ? __strcspn_c1 (s, __r0)                          \
  960.         : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0')          \
  961.            ? __strcspn_c2 (s, __r0, __r1)                      \
  962.            : (((__const char *) (reject))[3] == '\0'              \
  963.           ? __strcspn_c3 (s, __r0, __r1, __r2)                  \
  964.           : strcspn (s, reject)))))                      \
  965.       : strcspn (s, reject)); })
  966. #  endif
  967. # endif
  968.  
  969. __STRING_INLINE size_t __strcspn_c1 (__const char *__s, int __reject);
  970. __STRING_INLINE size_t
  971. __strcspn_c1 (__const char *__s, int __reject)
  972. {
  973.   register size_t __result = 0;
  974.   while (__s[__result] != '\0' && __s[__result] != __reject)
  975.     ++__result;
  976.   return __result;
  977. }
  978.  
  979. __STRING_INLINE size_t __strcspn_c2 (__const char *__s, int __reject1,
  980.                      int __reject2);
  981. __STRING_INLINE size_t
  982. __strcspn_c2 (__const char *__s, int __reject1, int __reject2)
  983. {
  984.   register size_t __result = 0;
  985.   while (__s[__result] != '\0' && __s[__result] != __reject1
  986.      && __s[__result] != __reject2)
  987.     ++__result;
  988.   return __result;
  989. }
  990.  
  991. __STRING_INLINE size_t __strcspn_c3 (__const char *__s, int __reject1,
  992.                      int __reject2, int __reject3);
  993. __STRING_INLINE size_t
  994. __strcspn_c3 (__const char *__s, int __reject1, int __reject2,
  995.           int __reject3)
  996. {
  997.   register size_t __result = 0;
  998.   while (__s[__result] != '\0' && __s[__result] != __reject1
  999.      && __s[__result] != __reject2 && __s[__result] != __reject3)
  1000.     ++__result;
  1001.   return __result;
  1002. }
  1003. #endif
  1004.  
  1005.  
  1006. /* Return the length of the initial segment of S which
  1007.    consists entirely of characters in ACCEPT.  */
  1008. #if !defined _HAVE_STRING_ARCH_strspn || defined _FORCE_INLINES
  1009. # ifndef _HAVE_STRING_ARCH_strspn
  1010. #  if __GNUC_PREREQ (3, 2)
  1011. #   define strspn(s, accept) \
  1012.   __extension__                                      \
  1013.   ({ char __a0, __a1, __a2;                              \
  1014.      (__builtin_constant_p (accept) && __string2_1bptr_p (accept)          \
  1015.       ? ((__builtin_constant_p (s) && __string2_1bptr_p (s))              \
  1016.      ? __builtin_strspn (s, accept)                          \
  1017.      : ((__a0 = ((__const char *) (accept))[0], __a0 == '\0')          \
  1018.         ? ((void) (s), 0)                              \
  1019.         : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0')          \
  1020.            ? __strspn_c1 (s, __a0)                          \
  1021.            : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0')          \
  1022.           ? __strspn_c2 (s, __a0, __a1)                      \
  1023.           : (((__const char *) (accept))[3] == '\0'              \
  1024.              ? __strspn_c3 (s, __a0, __a1, __a2)              \
  1025.              : __builtin_strspn (s, accept))))))              \
  1026.       : __builtin_strspn (s, accept)); })
  1027. #  else
  1028. #   define strspn(s, accept) \
  1029.   __extension__                                      \
  1030.   ({ char __a0, __a1, __a2;                              \
  1031.      (__builtin_constant_p (accept) && __string2_1bptr_p (accept)          \
  1032.       ? ((__a0 = ((__const char *) (accept))[0], __a0 == '\0')              \
  1033.      ? ((void) (s), 0)                              \
  1034.      : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0')          \
  1035.         ? __strspn_c1 (s, __a0)                          \
  1036.         : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0')          \
  1037.            ? __strspn_c2 (s, __a0, __a1)                      \
  1038.            : (((__const char *) (accept))[3] == '\0'              \
  1039.           ? __strspn_c3 (s, __a0, __a1, __a2)                  \
  1040.           : strspn (s, accept)))))                      \
  1041.       : strspn (s, accept)); })
  1042. #  endif
  1043. # endif
  1044.  
  1045. __STRING_INLINE size_t __strspn_c1 (__const char *__s, int __accept);
  1046. __STRING_INLINE size_t
  1047. __strspn_c1 (__const char *__s, int __accept)
  1048. {
  1049.   register size_t __result = 0;
  1050.   /* Please note that __accept never can be '\0'.  */
  1051.   while (__s[__result] == __accept)
  1052.     ++__result;
  1053.   return __result;
  1054. }
  1055.  
  1056. __STRING_INLINE size_t __strspn_c2 (__const char *__s, int __accept1,
  1057.                     int __accept2);
  1058. __STRING_INLINE size_t
  1059. __strspn_c2 (__const char *__s, int __accept1, int __accept2)
  1060. {
  1061.   register size_t __result = 0;
  1062.   /* Please note that __accept1 and __accept2 never can be '\0'.  */
  1063.   while (__s[__result] == __accept1 || __s[__result] == __accept2)
  1064.     ++__result;
  1065.   return __result;
  1066. }
  1067.  
  1068. __STRING_INLINE size_t __strspn_c3 (__const char *__s, int __accept1,
  1069.                     int __accept2, int __accept3);
  1070. __STRING_INLINE size_t
  1071. __strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3)
  1072. {
  1073.   register size_t __result = 0;
  1074.   /* Please note that __accept1 to __accept3 never can be '\0'.  */
  1075.   while (__s[__result] == __accept1 || __s[__result] == __accept2
  1076.      || __s[__result] == __accept3)
  1077.     ++__result;
  1078.   return __result;
  1079. }
  1080. #endif
  1081.  
  1082.  
  1083. /* Find the first occurrence in S of any character in ACCEPT.  */
  1084. #if !defined _HAVE_STRING_ARCH_strpbrk || defined _FORCE_INLINES
  1085. # ifndef _HAVE_STRING_ARCH_strpbrk
  1086. #  if __GNUC_PREREQ (3, 2)
  1087. #   define strpbrk(s, accept) \
  1088.   __extension__                                      \
  1089.   ({ char __a0, __a1, __a2;                              \
  1090.      (__builtin_constant_p (accept) && __string2_1bptr_p (accept)          \
  1091.       ? ((__builtin_constant_p (s) && __string2_1bptr_p (s))              \
  1092.      ? __builtin_strpbrk (s, accept)                      \
  1093.      : ((__a0 = ((__const char  *) (accept))[0], __a0 == '\0')          \
  1094.         ? ((void) (s), (char *) NULL)                      \
  1095.         : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0')          \
  1096.            ? __builtin_strchr (s, __a0)                      \
  1097.            : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0')          \
  1098.           ? __strpbrk_c2 (s, __a0, __a1)                  \
  1099.           : (((__const char *) (accept))[3] == '\0'              \
  1100.              ? __strpbrk_c3 (s, __a0, __a1, __a2)              \
  1101.              : __builtin_strpbrk (s, accept))))))              \
  1102.       : __builtin_strpbrk (s, accept)); })
  1103. #  else
  1104. #   define strpbrk(s, accept) \
  1105.   __extension__                                      \
  1106.   ({ char __a0, __a1, __a2;                              \
  1107.      (__builtin_constant_p (accept) && __string2_1bptr_p (accept)          \
  1108.       ? ((__a0 = ((__const char  *) (accept))[0], __a0 == '\0')              \
  1109.      ? ((void) (s), (char *) NULL)                          \
  1110.      : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0')          \
  1111.         ? strchr (s, __a0)                              \
  1112.         : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0')          \
  1113.            ? __strpbrk_c2 (s, __a0, __a1)                      \
  1114.            : (((__const char *) (accept))[3] == '\0'              \
  1115.           ? __strpbrk_c3 (s, __a0, __a1, __a2)                  \
  1116.           : strpbrk (s, accept)))))                      \
  1117.       : strpbrk (s, accept)); })
  1118. #  endif
  1119. # endif
  1120.  
  1121. __STRING_INLINE char *__strpbrk_c2 (__const char *__s, int __accept1,
  1122.                      int __accept2);
  1123. __STRING_INLINE char *
  1124. __strpbrk_c2 (__const char *__s, int __accept1, int __accept2)
  1125. {
  1126.   /* Please note that __accept1 and __accept2 never can be '\0'.  */
  1127.   while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
  1128.     ++__s;
  1129.   return *__s == '\0' ? NULL : (char *) (size_t) __s;
  1130. }
  1131.  
  1132. __STRING_INLINE char *__strpbrk_c3 (__const char *__s, int __accept1,
  1133.                      int __accept2, int __accept3);
  1134. __STRING_INLINE char *
  1135. __strpbrk_c3 (__const char *__s, int __accept1, int __accept2,
  1136.           int __accept3)
  1137. {
  1138.   /* Please note that __accept1 to __accept3 never can be '\0'.  */
  1139.   while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
  1140.      && *__s != __accept3)
  1141.     ++__s;
  1142.   return *__s == '\0' ? NULL : (char *) (size_t) __s;
  1143. }
  1144. #endif
  1145.  
  1146.  
  1147. /* Find the first occurrence of NEEDLE in HAYSTACK.  Newer gcc versions
  1148.    do this itself.  */
  1149. #if !defined _HAVE_STRING_ARCH_strstr && !__GNUC_PREREQ (2, 97)
  1150. # define strstr(haystack, needle) \
  1151.   (__extension__ (__builtin_constant_p (needle) && __string2_1bptr_p (needle) \
  1152.           ? (((__const char *) (needle))[0] == '\0'              \
  1153.              ? (char *) (size_t) (haystack)                  \
  1154.              : (((__const char *) (needle))[1] == '\0'              \
  1155.             ? strchr (haystack,                      \
  1156.                   ((__const char *) (needle))[0])           \
  1157.             : strstr (haystack, needle)))                  \
  1158.           : strstr (haystack, needle)))
  1159. #endif
  1160.  
  1161.  
  1162. #if !defined _HAVE_STRING_ARCH_strtok_r || defined _FORCE_INLINES
  1163. # ifndef _HAVE_STRING_ARCH_strtok_r
  1164. #  define __strtok_r(s, sep, nextp) \
  1165.   (__extension__ (__builtin_constant_p (sep) && __string2_1bptr_p (sep)          \
  1166.           ? (((__const char *) (sep))[0] != '\0'              \
  1167.              && ((__const char *) (sep))[1] == '\0'              \
  1168.              ? __strtok_r_1c (s, ((__const char *) (sep))[0], nextp)  \
  1169.              : __strtok_r (s, sep, nextp))                  \
  1170.           : __strtok_r (s, sep, nextp)))
  1171. # endif
  1172.  
  1173. __STRING_INLINE char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
  1174. __STRING_INLINE char *
  1175. __strtok_r_1c (char *__s, char __sep, char **__nextp)
  1176. {
  1177.   char *__result;
  1178.   if (__s == NULL)
  1179.     __s = *__nextp;
  1180.   while (*__s == __sep)
  1181.     ++__s;
  1182.   __result = NULL;
  1183.   if (*__s != '\0')
  1184.     {
  1185.       __result = __s++;
  1186.       while (*__s != '\0')
  1187.     if (*__s++ == __sep)
  1188.       {
  1189.         __s[-1] = '\0';
  1190.         break;
  1191.       }
  1192.       *__nextp = __s;
  1193.     }
  1194.   return __result;
  1195. }
  1196. # if defined __USE_POSIX || defined __USE_MISC
  1197. #  define strtok_r(s, sep, nextp) __strtok_r (s, sep, nextp)
  1198. # endif
  1199. #endif
  1200.  
  1201.  
  1202. #if !defined _HAVE_STRING_ARCH_strsep || defined _FORCE_INLINES
  1203. # ifndef _HAVE_STRING_ARCH_strsep
  1204.  
  1205. extern char *__strsep_g (char **__stringp, __const char *__delim);
  1206. #  define __strsep(s, reject) \
  1207.   __extension__                                      \
  1208.   ({ char __r0, __r1, __r2;                              \
  1209.      (__builtin_constant_p (reject) && __string2_1bptr_p (reject)          \
  1210.       && (__r0 = ((__const char *) (reject))[0],                  \
  1211.       ((__const char *) (reject))[0] != '\0')                  \
  1212.       ? ((__r1 = ((__const char *) (reject))[1],                  \
  1213.      ((__const char *) (reject))[1] == '\0')                  \
  1214.      ? __strsep_1c (s, __r0)                          \
  1215.      : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0')          \
  1216.         ? __strsep_2c (s, __r0, __r1)                      \
  1217.         : (((__const char *) (reject))[3] == '\0'                  \
  1218.            ? __strsep_3c (s, __r0, __r1, __r2)                  \
  1219.            : __strsep_g (s, reject))))                      \
  1220.       : __strsep_g (s, reject)); })
  1221. # endif
  1222.  
  1223. __STRING_INLINE char *__strsep_1c (char **__s, char __reject);
  1224. __STRING_INLINE char *
  1225. __strsep_1c (char **__s, char __reject)
  1226. {
  1227.   register char *__retval = *__s;
  1228.   if (__retval != NULL && (*__s = strchr (__retval, __reject)) != NULL)
  1229.     *(*__s)++ = '\0';
  1230.   return __retval;
  1231. }
  1232.  
  1233. __STRING_INLINE char *__strsep_2c (char **__s, char __reject1, char __reject2);
  1234. __STRING_INLINE char *
  1235. __strsep_2c (char **__s, char __reject1, char __reject2)
  1236. {
  1237.   register char *__retval = *__s;
  1238.   if (__retval != NULL)
  1239.     {
  1240.       register char *__cp = __retval;
  1241.       while (1)
  1242.     {
  1243.       if (*__cp == '\0')
  1244.         {
  1245.           __cp = NULL;
  1246.       break;
  1247.         }
  1248.       if (*__cp == __reject1 || *__cp == __reject2)
  1249.         {
  1250.           *__cp++ = '\0';
  1251.           break;
  1252.         }
  1253.       ++__cp;
  1254.     }
  1255.       *__s = __cp;
  1256.     }
  1257.   return __retval;
  1258. }
  1259.  
  1260. __STRING_INLINE char *__strsep_3c (char **__s, char __reject1, char __reject2,
  1261.                    char __reject3);
  1262. __STRING_INLINE char *
  1263. __strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
  1264. {
  1265.   register char *__retval = *__s;
  1266.   if (__retval != NULL)
  1267.     {
  1268.       register char *__cp = __retval;
  1269.       while (1)
  1270.     {
  1271.       if (*__cp == '\0')
  1272.         {
  1273.           __cp = NULL;
  1274.       break;
  1275.         }
  1276.       if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
  1277.         {
  1278.           *__cp++ = '\0';
  1279.           break;
  1280.         }
  1281.       ++__cp;
  1282.     }
  1283.       *__s = __cp;
  1284.     }
  1285.   return __retval;
  1286. }
  1287. # ifdef __USE_BSD
  1288. #  define strsep(s, reject) __strsep (s, reject)
  1289. # endif
  1290. #endif
  1291.  
  1292. /* We need the memory allocation functions for inline strdup().
  1293.    Referring to stdlib.h (even minimally) is not allowed
  1294.    in any of the tight standards compliant modes.  */
  1295. #ifdef __USE_MISC
  1296.  
  1297. # if !defined _HAVE_STRING_ARCH_strdup || !defined _HAVE_STRING_ARCH_strndup
  1298. #  define __need_malloc_and_calloc
  1299. #  include <stdlib.h>
  1300. # endif
  1301.  
  1302. # ifndef _HAVE_STRING_ARCH_strdup
  1303.  
  1304. extern char *__strdup (__const char *__string) __THROW __attribute_malloc__;
  1305. #  define __strdup(s) \
  1306.   (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s)          \
  1307.           ? (((__const char *) (s))[0] == '\0'                  \
  1308.              ? (char *) calloc (1, 1)                      \
  1309.              : ({ size_t __len = strlen (s) + 1;              \
  1310.               char *__retval = (char *) malloc (__len);          \
  1311.               if (__retval != NULL)                      \
  1312.                 __retval = (char *) memcpy (__retval, s, __len);  \
  1313.               __retval; }))                          \
  1314.           : __strdup (s)))
  1315.  
  1316. #  if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED
  1317. #   define strdup(s) __strdup (s)
  1318. #  endif
  1319. # endif
  1320.  
  1321. # ifndef _HAVE_STRING_ARCH_strndup
  1322.  
  1323. extern char *__strndup (__const char *__string, size_t __n)
  1324.      __THROW __attribute_malloc__;
  1325. #  define __strndup(s, n) \
  1326.   (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s)          \
  1327.           ? (((__const char *) (s))[0] == '\0'                  \
  1328.              ? (char *) calloc (1, 1)                      \
  1329.              : ({ size_t __len = strlen (s) + 1;              \
  1330.               size_t __n = (n);                      \
  1331.               char *__retval;                      \
  1332.               if (__n < __len)                      \
  1333.                 __len = __n + 1;                      \
  1334.               __retval = (char *) malloc (__len);              \
  1335.               if (__retval != NULL)                      \
  1336.                 {                              \
  1337.                   __retval[__len - 1] = '\0';              \
  1338.                   __retval = (char *) memcpy (__retval, s,          \
  1339.                               __len - 1);          \
  1340.                 }                              \
  1341.               __retval; }))                          \
  1342.           : __strndup (s, n)))
  1343.  
  1344. #  ifdef __USE_GNU
  1345. #   define strndup(s, n) __strndup (s, n)
  1346. #  endif
  1347. # endif
  1348.  
  1349. #endif /* Use misc. or use GNU.  */
  1350.  
  1351. #ifndef _FORCE_INLINES
  1352. # undef __STRING_INLINE
  1353. #endif
  1354.  
  1355. #endif /* No string inlines.  */
  1356.